package cn.com.open.itembank.entity;

import cn.com.open.itembank.common.BaseModel;

/**
 * Created by lucky on 2017/9/1.
 */
public class Question extends BaseModel {
    /**
     * 试题ID
     */
    private String questionId;

    /**
     * 题型ID
     */
    private String questionTypeId;

    /**
     * 试题类别
     */
    private String questionCategory;

    /**
     * 难度系数
     */
    private double difficulty;

    /**
     * 试题标题
     */
    private String title;

    /**
     * 说明
     */
    private String comment;

    /**
     * 建议分值
     */
    private double score;

    /**
     * 关键字
     */
    private String keywords;

    /**
     * 题目分析
     */
    private String questionAnalysis;

    /**
     * 子题数
     */
    private Integer fieldCount;

    /**
     * 创建人
     */
    private String creater;

    /**
     * 创建时间
     */
    private String createTime;

    /**
     * 状态：0，正常；1，停用；9，系统停用
     */
    private Integer status;

    /**
     * 0，未审核；1，已审核
     */
    private Integer isCheck;

    /**
     * 审核人
     */
    private String checker;

    /**
     * 审核时间
     */
    private String checkTime;

    /**
     * 最后修改时间
     */
    private String lastUpdateTime;

    /**
     * 曝光次数
     */
    private Integer displayCount;

    /**
     * 最近曝光时间
     */
    private String displayTime;

    /**
     * 0，内部；1，外部
     */
    private Integer source;

    /**
     * 是否课程试题：0，否；1，是
     */
    private Integer isCourseOnly;

    /**
     * 录题方式：0，手工录入；1，文件导入
     */
    private Integer inputType;

    /**
     * 导入方式：0，无；1，word导入；2，excel导入
     */
    private Integer importType;

    /**
     * 来源类型：0，试题录入；1，试卷录入
     */
    private Integer sourceType;

    /**
     * 父试题ID
     */
    private String parentQuestionId;

    /**
     * 是否是子试题：0，不是；1，是
     */
    private Integer isSubQuestion;

    /**
     * 排序序号
     */
    private Integer sequenceIndex;

    /**
     * 是否是主观题：0，不是；1，是
     */
    private Integer isSubjective;

    /**
     * 是否乱序：0，否；1，是
     */
    private Integer shuffle;

    /**  */
    private Integer serialNumber;

    /**
     * 试题版本：每审核一次，版本号加1**
     */
    private Integer questionVersion;

    /**
     * 区分度：测验能达到预期区分要求的程度。1 到 9逐渐增加
     */
    private Integer difference;

    /**
     * 认知分类：识记、能力、应用**
     */
    private Integer perceiver;

    /**
     * 掌握程度：了解、掌握、重点掌握**
     */
    private Integer masterLevel;

    /**
     * 建议答题时间（分钟）
     */
    private Integer responseTime;

    /**
     * 内部题型编号
     * 1：单选题，2：多选题，3：判断题，4：填空题，5：组合选择题，6：主观题
     */
    private Integer questionInnerTypeId;

    /** 最后编辑者 */
    private String modifier;

    /** 最后编辑时间 */
    private String modifyTime;

    /**
     * 媒体类型：0，无媒体；1，音频；2，视频
     */
    private Integer mediaType;

    /** 媒体时长 */
    private Integer mediaDuration;

    /**
     * 发布标记：0，未发布；1，已发布
     */
    private Integer isPublish;

    /** 发布人 */
    private String publisherId;

    /** 发布时间 */
    private String publishTime;

    /** 试题质量 */
    private Integer qualityGrade;

    /**
     * 状态：0，私有，1，共享
     */
    private Integer useType;

    /**
     * 获取试题ID
     *
     * @return 试题ID question id
     */
    public String getQuestionId() {
        return this.questionId;
    }

    /**
     * 设置试题ID
     *
     * @param questionId 试题ID
     */
    public void setQuestionId(String questionId) {
        this.questionId = questionId;
    }

    /**
     * 获取题型ID
     *
     * @return 题型ID question type id
     */
    public String getQuestionTypeId() {
        return this.questionTypeId;
    }

    /**
     * 设置题型ID
     *
     * @param questionTypeId 题型ID
     */
    public void setQuestionTypeId(String questionTypeId) {
        this.questionTypeId = questionTypeId;
    }

    /**
     * 获取试题类别
     *
     * @return 试题类别 question category
     */
    public String getQuestionCategory() {
        return this.questionCategory;
    }

    /**
     * 设置试题类别
     *
     * @param questionCategory 试题类别
     */
    public void setQuestionCategory(String questionCategory) {
        this.questionCategory = questionCategory;
    }

    /**
     * 获取难度系数
     *
     * @return 难度系数 difficulty
     */
    public double getDifficulty() {
        return this.difficulty;
    }

    /**
     * 设置难度系数
     *
     * @param difficulty 难度系数
     */
    public void setDifficulty(double difficulty) {
        this.difficulty = difficulty;
    }

    /**
     * 获取试题标题
     *
     * @return 试题标题 title
     */
    public String getTitle() {
        return this.title;
    }

    /**
     * 设置试题标题
     *
     * @param title 试题标题
     */
    public void setTitle(String title) {
        this.title = title;
    }

    /**
     * 获取说明
     *
     * @return 说明 comment
     */
    public String getComment() {
        return this.comment;
    }

    /**
     * 设置说明
     *
     * @param comment 说明
     */
    public void setComment(String comment) {
        this.comment = comment;
    }

    /**
     * 获取建议分值
     *
     * @return 建议分值 score
     */
    public double getScore() {
        return this.score;
    }

    /**
     * 设置建议分值
     *
     * @param score 建议分值
     */
    public void setScore(double score) {
        this.score = score;
    }

    /**
     * 获取关键字
     *
     * @return 关键字 keywords
     */
    public String getKeywords() {
        return this.keywords;
    }

    /**
     * 设置关键字
     *
     * @param keywords 关键字
     */
    public void setKeywords(String keywords) {
        this.keywords = keywords;
    }

    /**
     * 获取题目分析
     *
     * @return 题目分析 question analysis
     */
    public String getQuestionAnalysis() {
        return this.questionAnalysis;
    }

    /**
     * 设置题目分析
     *
     * @param questionAnalysis 题目分析
     */
    public void setQuestionAnalysis(String questionAnalysis) {
        this.questionAnalysis = questionAnalysis;
    }

    /**
     * 获取子题数
     *
     * @return 子题数 field count
     */
    public Integer getFieldCount() {
        return this.fieldCount;
    }

    /**
     * 设置子题数
     *
     * @param fieldCount 子题数
     */
    public void setFieldCount(Integer fieldCount) {
        this.fieldCount = fieldCount;
    }

    /**
     * 获取创建人
     *
     * @return 创建人 creater
     */
    public String getCreater() {
        return this.creater;
    }

    /**
     * 设置创建人
     *
     * @param creater 创建人
     */
    public void setCreater(String creater) {
        this.creater = creater;
    }

    /**
     * 获取创建时间
     *
     * @return 创建时间 create time
     */
    public String getCreateTime() {
        return this.createTime;
    }

    /**
     * 设置创建时间
     *
     * @param createTime 创建时间
     */
    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }

    /**
     * 获取状态：0，正常；1，停用；9，系统停用
     *
     * @return 状态 ：0
     */
    public Integer getStatus() {
        return this.status;
    }

    /**
     * 设置状态：0，正常；1，停用；9，系统停用
     *
     * @param status 状态：0，正常；1，停用；9，系统停用
     */
    public void setStatus(Integer status) {
        this.status = status;
    }

    /**
     * 获取0，未审核；1，已审核
     *
     * @return 0 ，未审核；1，已审核
     */
    public Integer getIsCheck() {
        return this.isCheck;
    }

    /**
     * 设置0，未审核；1，已审核
     *
     * @param isCheck 0，未审核；1，已审核
     */
    public void setIsCheck(Integer isCheck) {
        this.isCheck = isCheck;
    }

    /**
     * 获取审核人
     *
     * @return 审核人 checker
     */
    public String getChecker() {
        return this.checker;
    }

    /**
     * 设置审核人
     *
     * @param checker 审核人
     */
    public void setChecker(String checker) {
        this.checker = checker;
    }

    /**
     * 获取审核时间
     *
     * @return 审核时间 check time
     */
    public String getCheckTime() {
        return this.checkTime;
    }

    /**
     * 设置审核时间
     *
     * @param checkTime 审核时间
     */
    public void setCheckTime(String checkTime) {
        this.checkTime = checkTime;
    }

    /**
     * 获取最后修改时间
     *
     * @return 最后修改时间 last updatetime
     */
    public String getLastUpdateTime() {
        return this.lastUpdateTime;
    }

    /**
     * 设置最后修改时间
     *
     * @param lastUpdateTime 最后修改时间
     */
    public void setLastUpdateTime(String lastUpdateTime) {
        this.lastUpdateTime = lastUpdateTime;
    }

    /**
     * 获取曝光次数
     *
     * @return 曝光次数 display count
     */
    public Integer getDisplayCount() {
        return this.displayCount;
    }

    /**
     * 设置曝光次数
     *
     * @param displayCount 曝光次数
     */
    public void setDisplayCount(Integer displayCount) {
        this.displayCount = displayCount;
    }

    /**
     * 获取最近曝光时间
     *
     * @return 最近曝光时间 display time
     */
    public String getDisplayTime() {
        return this.displayTime;
    }

    /**
     * 设置最近曝光时间
     *
     * @param displayTime 最近曝光时间
     */
    public void setDisplayTime(String displayTime) {
        this.displayTime = displayTime;
    }

    /**
     * 获取0，内部；1，外部
     *
     * @return 0 ，内部；1，外部
     */
    public Integer getSource() {
        return this.source;
    }

    /**
     * 设置0，内部；1，外部
     *
     * @param source 0，内部；1，外部
     */
    public void setSource(Integer source) {
        this.source = source;
    }

    /**
     * 获取是否课程试题：0，否；1，是
     *
     * @return 是否课程试题 ：0
     */
    public Integer getIsCourseOnly() {
        return this.isCourseOnly;
    }

    /**
     * 设置是否课程试题：0，否；1，是
     *
     * @param isCourseOnly 是否课程试题：0，否；1，是
     */
    public void setIsCourseOnly(Integer isCourseOnly) {
        this.isCourseOnly = isCourseOnly;
    }

    /**
     * 获取录题方式：0，手工录入；1，文件导入
     *
     * @return 录题方式 ：0
     */
    public Integer getInputType() {
        return this.inputType;
    }

    /**
     * 设置录题方式：0，手工录入；1，文件导入
     *
     * @param inputType 录题方式：0，手工录入；1，文件导入
     */
    public void setInputType(Integer inputType) {
        this.inputType = inputType;
    }

    /**
     * 获取导入方式：0，无；1，word导入；2，excel导入
     *
     * @return 导入方式 ：0
     */
    public Integer getImportType() {
        return this.importType;
    }

    /**
     * 设置导入方式：0，无；1，word导入；2，excel导入
     *
     * @param importType 导入方式：0，无；1，word导入；2，excel导入
     */
    public void setImportType(Integer importType) {
        this.importType = importType;
    }

    /**
     * 获取来源类型：0，试题录入；1，试卷录入
     *
     * @return 来源类型 ：0
     */
    public Integer getSourceType() {
        return this.sourceType;
    }

    /**
     * 设置来源类型：0，试题录入；1，试卷录入
     *
     * @param sourceType 来源类型：0，试题录入；1，试卷录入
     */
    public void setSourceType(Integer sourceType) {
        this.sourceType = sourceType;
    }

    /**
     * 获取父试题ID
     *
     * @return 父试题ID parent question id
     */
    public String getParentQuestionId() {
        return this.parentQuestionId;
    }

    /**
     * 设置父试题ID
     *
     * @param parentQuestionId 父试题ID
     */
    public void setParentQuestionId(String parentQuestionId) {
        this.parentQuestionId = parentQuestionId;
    }

    /**
     * 获取是否是子试题：0，不是；1，是
     *
     * @return 是否是子试题 ：0
     */
    public Integer getIsSubQuestion() {
        return this.isSubQuestion;
    }

    /**
     * 设置是否是子试题：0，不是；1，是
     *
     * @param isSubQuestion 是否是子试题：0，不是；1，是
     */
    public void setIsSubQuestion(Integer isSubQuestion) {
        this.isSubQuestion = isSubQuestion;
    }

    /**
     * 获取排序序号
     *
     * @return 排序序号 sequence index
     */
    public Integer getSequenceIndex() {
        return this.sequenceIndex;
    }

    /**
     * 设置排序序号
     *
     * @param sequenceIndex 排序序号
     */
    public void setSequenceIndex(Integer sequenceIndex) {
        this.sequenceIndex = sequenceIndex;
    }

    /**
     * 获取是否是主观题：0，不是；1，是
     *
     * @return 是否是主观题 ：0
     */
    public Integer getIsSubjective() {
        return this.isSubjective;
    }

    /**
     * 设置是否是主观题：0，不是；1，是
     *
     * @param isSubjective 是否是主观题：0，不是；1，是
     */
    public void setIsSubjective(Integer isSubjective) {
        this.isSubjective = isSubjective;
    }

    /**
     * 获取是否乱序：0，否；1，是
     *
     * @return 是否乱序 ：0
     */
    public Integer getShuffle() {
        return this.shuffle;
    }

    /**
     * 设置是否乱序：0，否；1，是
     *
     * @param shuffle 是否乱序：0，否；1，是
     */
    public void setShuffle(Integer shuffle) {
        this.shuffle = shuffle;
    }

    /**
     * 获取serialnumber
     *
     * @return serialNumber serial number
     */
    public Integer getSerialNumber() {
        return this.serialNumber;
    }

    /**
     * 设置serialnumber
     *
     * @param serialNumber serialNumber
     */
    public void setSerialNumber(Integer serialNumber) {
        this.serialNumber = serialNumber;
    }

    /**
     * 获取试题版本：每审核一次，版本号加1**
     *
     * @return 试题版本 ：每审核一次
     */
    public Integer getQuestionVersion() {
        return this.questionVersion;
    }

    /**
     * 设置试题版本：每审核一次，版本号加1**
     *
     * @param questionVersion 试题版本：每审核一次，版本号加1
     **/
    public void setQuestionVersion(Integer questionVersion) {
        this.questionVersion = questionVersion;
    }

    /**
     * 获取区分度：测验能达到预期区分要求的程度。1 到 9逐渐增加
     *
     * @return 区分度 difference
     */
    public Integer getDifference() {
        return this.difference;
    }

    /**
     * 设置区分度：测验能达到预期区分要求的程度。1 到 9逐渐增加
     *
     * @param difference 区分度：测验能达到预期区分要求的程度。1 到 9逐渐增加
     */
    public void setDifference(Integer difference) {
        this.difference = difference;
    }

    /**
     * 获取认知分类：识记、能力、应用**
     *
     * @return 认知分类 perceiver
     */
    public Integer getPerceiver() {
        return this.perceiver;
    }

    /**
     * 设置认知分类：识记、能力、应用**
     *
     * @param perceiver 认知分类：识记、能力、应用
     **/
    public void setPerceiver(Integer perceiver) {
        this.perceiver = perceiver;
    }

    /**
     * 获取掌握程度：了解、掌握、重点掌握**
     *
     * @return 掌握程度 master level
     */
    public Integer getMasterLevel() {
        return this.masterLevel;
    }

    /**
     * 设置掌握程度：了解、掌握、重点掌握**
     *
     * @param masterLevel 掌握程度：了解、掌握、重点掌握
     **/
    public void setMasterLevel(Integer masterLevel) {
        this.masterLevel = masterLevel;
    }

    /**
     * 获取建议答题时间（分钟）
     *
     * @return 建议答题时间 （分钟）
     */
    public Integer getResponseTime() {
        return this.responseTime;
    }

    /**
     * 设置建议答题时间（分钟）
     *
     * @param responseTime 建议答题时间（分钟）
     */
    public void setResponseTime(Integer responseTime) {
        this.responseTime = responseTime;
    }

    /**
     * 获取内部题型编号
     * 1：单选题，2：多选题，3：判断题，4：填空题，5：组合选择题，6：主观题
     *
     * @return 内部题型编号  1：单选题
     */
    public Integer getQuestionInnerTypeId() {
        return this.questionInnerTypeId;
    }

    /**
     * 设置内部题型编号
     * 1：单选题，2：多选题，3：判断题，4：填空题，5：组合选择题，6：主观题
     *
     * @param questionInnerTypeId 内部题型编号                            1：单选题，2：多选题，3：判断题，4：填空题，5：组合选择题，6：主观题
     */
    public void setQuestionInnerTypeId(Integer questionInnerTypeId) {
        this.questionInnerTypeId = questionInnerTypeId;
    }

    /**
     * 获取modifier
     *
     * @return modifier modifier
     */
    public String getModifier() {
        return this.modifier;
    }

    /**
     * 设置modifier
     *
     * @param modifier modifier
     */
    public void setModifier(String modifier) {
        this.modifier = modifier;
    }

    /**
     * 获取modifytime
     *
     * @return modifyTime modify time
     */
    public String getModifyTime() {
        return this.modifyTime;
    }

    /**
     * 设置modifytime
     *
     * @param modifyTime modifyTime
     */
    public void setModifyTime(String modifyTime) {
        this.modifyTime = modifyTime;
    }

    /**
     * 获取媒体类型：0，无媒体；1，音频；2，视频
     *
     * @return 媒体类型 ：0
     */
    public Integer getMediaType() {
        return this.mediaType;
    }

    /**
     * 设置媒体类型：0，无媒体；1，音频；2，视频
     *
     * @param mediaType 媒体类型：0，无媒体；1，音频；2，视频
     */
    public void setMediaType(Integer mediaType) {
        this.mediaType = mediaType;
    }

    /**
     * 获取mediaduration
     *
     * @return mediaDuration media duration
     */
    public Integer getMediaDuration() {
        return this.mediaDuration;
    }

    /**
     * 设置mediaduration
     *
     * @param mediaDuration mediaDuration
     */
    public void setMediaDuration(Integer mediaDuration) {
        this.mediaDuration = mediaDuration;
    }

    /**
     * 获取发布标记：0，未发布；1，已发布
     *
     * @return 发布标记 ：0
     */
    public Integer getIsPublish() {
        return this.isPublish;
    }

    /**
     * 设置发布标记：0，未发布；1，已发布
     *
     * @param isPublish 发布标记：0，未发布；1，已发布
     */
    public void setIsPublish(Integer isPublish) {
        this.isPublish = isPublish;
    }

    /**
     * 获取publisherid
     *
     * @return publisherId publisherId
     */
    public String getPublisherId() {
        return this.publisherId;
    }

    /**
     * 设置publisherid
     *
     * @param publisherId publisherId
     */
    public void setPublisherId(String publisherId) {
        this.publisherId = publisherId;
    }

    /**
     * 获取publishtime
     *
     * @return publishTime publish time
     */
    public String getPublishTime() {
        return this.publishTime;
    }

    /**
     * 设置publishtime
     *
     * @param publishTime publishTime
     */
    public void setPublishTime(String publishTime) {
        this.publishTime = publishTime;
    }

    /**
     * 获取qualitygrade
     *
     * @return qualityGrade quality grade
     */
    public Integer getQualityGrade() {
        return this.qualityGrade;
    }

    /**
     * 设置qualitygrade
     *
     * @param qualityGrade qualityGrade
     */
    public void setQualityGrade(Integer qualityGrade) {
        this.qualityGrade = qualityGrade;
    }

    /**
     * 获取状态：0，私有，1，共享
     *
     * @return 状态 ：0
     */
    public Integer getUseType() {
        return this.useType;
    }

    /**
     * 设置状态：0，私有，1，共享
     *
     * @param useType 状态：0，私有，1，共享
     */
    public void setUseType(Integer useType) {
        this.useType = useType;
    }
}
